namespace ext.dd
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// Defines the interface and base operation of items that that can be
	/// dragged or can be drop targets. It was designed to be extended, overriding
	/// the event handlers for startDrag, onDrag, onDragOver and onDragOut.
	/// Up to three html elements can be associated with a DragDrop instance:
	///  linked element: the element that is passed into the constructor.
	/// This is the element which defines the boundaries for interaction with
	/// other DragDrop objects.  handle element(s): The drag operation only occurs if the element that
	/// was clicked matches a handle element. By default this is the linked
	/// element, but there are times that you will want only a portion of the
	/// linked element to initiate the drag operation, and the setHandleElId()
	/// method provides a way to define this.  drag element: this represents the element that would be moved along
	/// with the cursor during a drag operation. By default, this is the linked
	/// element itself as in {@link Ext.dd.DD}. setDragElId() lets you define
	/// a separate...
	/// </summary>
	/// <htmlSummary>
	/// Defines the interface and base operation of items that that can be
	/// dragged or can be drop targets. It was designed to be extended, overriding
	/// the event handlers for startDrag, onDrag, onDragOver and onDragOut.
	/// Up to three html elements can be associated with a DragDrop instance:
	/// &lt;ul&gt;
	/// &lt;li&gt;linked element: the element that is passed into the constructor.
	/// This is the element which defines the boundaries for interaction with
	/// other DragDrop objects.&lt;/li&gt;
	/// &lt;li&gt;handle element(s): The drag operation only occurs if the element that
	/// was clicked matches a handle element. By default this is the linked
	/// element, but there are times that you will want only a portion of the
	/// linked element to initiate the drag operation, and the setHandleElId()
	/// method provides a way to define this.&lt;/li&gt;
	/// &lt;li&gt;drag element: this represents the element that would be moved along
	/// with the cursor during a drag operation. By default, this is the linked
	/// element itself as in {@link Ext.dd.DD}. setDragElId() lets you define
	/// a separate element that would be moved, as in {@link Ext.dd.DDProxy}.
	/// &lt;/li&gt;
	/// &lt;/ul&gt;
	/// This class should not be instantiated until the onload event to ensure that
	/// the associated elements are available.
	/// The following would define a DragDrop obj that would interact with any
	/// other DragDrop obj in the &quot;group1&quot; group:
	/// &lt;pre&gt;
	/// dd = new Ext.dd.DragDrop(&quot;div1&quot;, &quot;group1&quot;);
	/// &lt;/pre&gt;
	/// Since none of the event handlers have been implemented, nothing would
	/// actually happen if you were to run the code above. Normally you would
	/// override this class or one of the default implementations, but you can
	/// also override the methods you want on an instance of the class...
	/// &lt;pre&gt;
	/// dd.onDragDrop = function(e, id) {
	/// &amp;nbsp;&amp;nbsp;alert(&quot;dd was dropped on &quot; + id);
	/// }
	/// &lt;/pre&gt;
	/// </htmlSummary>
	/// <definedin>src\dd\DDCore.js</definedin>
	[ScriptName("DragDrop")]
	[ScriptNamespace("Ext.dd")]
	[Imported()]
	public partial class DragDrop
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		/// <param name="id">of the element that is linked to this instance</param>
		/// <param name="sGroup">the group of related DragDrop objects</param>
		/// <param name="config">
		/// an object containing configurable attributes
		/// Valid properties for DragDrop:
		/// padding, isTarget, maintainOffset, primaryButtonOnly
		/// </param>
		public DragDrop(string id, string sGroup, object config)
		{
		}
		
		/// <summary>Constructor</summary>
		public DragDrop()
		{
		}
		#endregion
		
		#region Properties
		/// <summary>
		/// Set to false to enable a DragDrop object to fire drag events while dragging
		/// over its own Element. Defaults to true - DragDrop objects do not by default
		/// fire drag events to themselves.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("ignoreSelf")]
		[IntrinsicProperty()]
		public bool IgnoreSelf
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// The id of the element associated with this object. This is what we
		/// refer to as the &quot;linked element&quot; because the size and position of
		/// this element is used to determine when the drag and drop objects have
		/// interacted.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("id")]
		[IntrinsicProperty()]
		public string Id
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>Configuration attributes passed into the constructor</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("config")]
		[IntrinsicProperty()]
		public object Config
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// An object who&apos;s property names identify HTML tags to be considered invalid as drag handles.
		/// A non-null property value identifies the tag as invalid. Defaults to the
		/// following value which prevents drag operations from being initiated by &amp;lt;a&gt; elements: 
		/// {
		/// A: &quot;A&quot;
		/// }
		/// </summary>
		/// <htmlSummary>
		/// An object who&apos;s property names identify HTML tags to be considered invalid as drag handles.
		/// A non-null property value identifies the tag as invalid. Defaults to the
		/// following value which prevents drag operations from being initiated by &amp;lt;a&gt; elements:&lt;pre&gt;&lt;code&gt;
		/// {
		/// A: &quot;A&quot;
		/// }&lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("invalidHandleTypes")]
		[IntrinsicProperty()]
		public object InvalidHandleTypes
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// An object who&apos;s property names identify the IDs of elements to be considered invalid as drag handles.
		/// A non-null property value identifies the ID as invalid. For example, to prevent
		/// dragging from being initiated on element ID &quot;foo&quot;, use: 
		/// {
		/// foo: true
		/// }
		/// </summary>
		/// <htmlSummary>
		/// An object who&apos;s property names identify the IDs of elements to be considered invalid as drag handles.
		/// A non-null property value identifies the ID as invalid. For example, to prevent
		/// dragging from being initiated on element ID &quot;foo&quot;, use:&lt;pre&gt;&lt;code&gt;
		/// {
		/// foo: true
		/// }&lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("invalidHandleIds")]
		[IntrinsicProperty()]
		public object InvalidHandleIds
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>An Array of CSS class names for elements to be considered in valid as drag handles.</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("invalidHandleClasses")]
		[IntrinsicProperty()]
		public System.Array InvalidHandleClasses
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// The group defines a logical collection of DragDrop objects that are
		/// related. Instances only get events when interacting with other
		/// DragDrop object in the same group. This lets us define multiple
		/// groups using a single DragDrop subclass if we want.
		///
		/// An object in the format {&apos;group1&apos;:true, &apos;group2&apos;:true}
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("groups")]
		[IntrinsicProperty()]
		public object Groups
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// When set to true, other DD objects in cooperating DDGroups do not receive
		/// notification events when this DD object is dragged over them. Defaults to false.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("moveOnly")]
		[IntrinsicProperty()]
		public bool MoveOnly
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// By default, all instances can be a drop target. This can be disabled by
		/// setting isTarget to false.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("isTarget")]
		[IntrinsicProperty()]
		public bool IsTarget
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// The padding configured for this drag and drop object for calculating
		/// the drop zone intersection with this object.
		///
		/// An array containing the 4 padding values: [top, right, bottom, left]
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("padding")]
		[IntrinsicProperty()]
		public int[] Padding
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// Maintain offsets when we resetconstraints. Set to true when you want
		/// the position of the element relative to its parent to stay the same
		/// when the page changes
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("maintainOffset")]
		[IntrinsicProperty()]
		public bool MaintainOffset
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// Array of pixel locations the element will snap to if we specified a
		/// horizontal graduation/interval. This array is generated automatically
		/// when you define a tick interval.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("xTicks")]
		[IntrinsicProperty()]
		public int[] XTicks
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// Array of pixel locations the element will snap to if we specified a
		/// vertical graduation/interval. This array is generated automatically
		/// when you define a tick interval.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("yTicks")]
		[IntrinsicProperty()]
		public int[] YTicks
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// By default the drag and drop instance will only respond to the primary
		/// button click (left button for a right-handed mouse). Set to true to
		/// allow drag and drop to start with any mouse click that is propogated
		/// by the browser
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("primaryButtonOnly")]
		[IntrinsicProperty()]
		public bool PrimaryButtonOnly
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>The available property is false until the linked dom element is accessible.</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("available")]
		[IntrinsicProperty()]
		public bool Available
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// By default, drags can only be initiated if the mousedown occurs in the
		/// region the linked element is. This is done in part to work around a
		/// bug in some browsers that mis-report the mousedown if the previous
		/// mouseup happened outside of the window. This property is set to true
		/// if outer handles are defined.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("hasOuterHandles")]
		[IntrinsicProperty()]
		public bool HasOuterHandles
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>Provides default constraint padding to &quot;constrainTo&quot; elements (defaults to {left: 0, right:0, top:0, bottom:0}).</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("defaultPadding")]
		[IntrinsicProperty()]
		public object DefaultPadding
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>Lock this instance</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("lock")]
		public void Lock()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Unlock this instace</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("unlock")]
		public void Unlock()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Abstract method called after a drag/drop object is clicked
		/// and the drag or mousedown time thresholds have beeen met.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="X">click location</param>
		/// <param name="Y">click location</param>
		[ScriptName("startDrag")]
		public void StartDrag(int X, int Y)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Abstract method called during the onMouseMove event while dragging an
		/// object.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mousemove event</param>
		[ScriptName("onDrag")]
		public void OnDrag(System.Html.ElementEvent e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Abstract method called when this item is dropped on an area with no
		/// drop target
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mouseup event</param>
		[ScriptName("onInvalidDrop")]
		public void OnInvalidDrop(System.Html.ElementEvent e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Fired when we are done dragging the object</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mouseup event</param>
		[ScriptName("endDrag")]
		public void EndDrag(System.Html.ElementEvent e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Event handler that fires when a drag/drop obj gets a mousedown</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mousedown event</param>
		[ScriptName("onMouseDown")]
		public void OnMouseDown(System.Html.ElementEvent e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Event handler that fires when a drag/drop obj gets a mouseup</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mouseup event</param>
		[ScriptName("onMouseUp")]
		public void OnMouseUp(System.Html.ElementEvent e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Override the onAvailable method to do what is needed after the initial
		/// position was determined.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("onAvailable")]
		public void OnAvailable()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns a reference to the linked element</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <returns>the html element</returns>
		[ScriptName("getEl")]
		public System.Html.Element GetEl()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns a reference to the actual element to drag. By default this is
		/// the same as the html element, but it can be assigned to another
		/// element. An example of this can be found in Ext.dd.DDProxy
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <returns>the html element</returns>
		[ScriptName("getDragEl")]
		public System.Html.Element GetDragEl()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets up the DragDrop object. Must be called in the constructor of any
		/// Ext.dd.DragDrop subclass
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">id of the linked element</param>
		/// <param name="sGroup">the group of related items</param>
		/// <param name="config">configuration attributes</param>
		[ScriptName("init")]
		public void Init(string id, string sGroup, object config)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes Targeting functionality only... the object does not
		/// get a mousedown handler.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">id of the linked element</param>
		/// <param name="sGroup">the group of related items</param>
		/// <param name="config">configuration attributes</param>
		[ScriptName("initTarget")]
		public void InitTarget(string id, string sGroup, object config)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Applies the configuration parameters that were passed into the constructor.
		/// This is supposed to happen at each level through the inheritance chain. So
		/// a DDProxy implentation will execute apply config on DDProxy, DD, and
		/// DragDrop in order to get all of the parameters that are available in
		/// each object.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("applyConfig")]
		public void ApplyConfig()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Configures the padding for the target zone in px. Effectively expands
		/// (or reduces) the virtual object size for targeting calculations.
		/// Supports css-style shorthand; if only one parameter is passed, all sides
		/// will have that padding, and if only two are passed, the top and bottom
		/// will have the first param, the left and right the second.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="iTop">Top pad</param>
		/// <param name="iRight">Right pad</param>
		/// <param name="iBot">Bot pad</param>
		/// <param name="iLeft">Left pad</param>
		[ScriptName("setPadding")]
		public void SetPadding(int iTop, int iRight, int iBot, int iLeft)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Stores the initial placement of the linked element.</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="diffX">the X offset, default 0</param>
		/// <param name="diffY">the Y offset, default 0</param>
		[ScriptName("setInitPosition")]
		public void SetInitPosition(int diffX, int diffY)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Add this instance to a group of related drag/drop objects. All
		/// instances belong to at least one group, and can belong to as many
		/// groups as needed.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="sGroup">the name of the group</param>
		[ScriptName("addToGroup")]
		public void AddToGroup(string sGroup)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Remove&apos;s this instance from the supplied interaction group</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="sGroup">The group to drop</param>
		[ScriptName("removeFromGroup")]
		public void RemoveFromGroup(string sGroup)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Allows you to specify that an element other than the linked element
		/// will be moved with the cursor during a drag
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">the id of the element that will be used to initiate the drag</param>
		[ScriptName("setDragElId")]
		public void SetDragElId(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Allows you to specify a child of the linked element that should be
		/// used to initiate the drag operation. An example of this would be if
		/// you have a content div with text and links. Clicking anywhere in the
		/// content area would normally start the drag operation. Use this method
		/// to specify that an element inside of the content div is the element
		/// that starts the drag operation.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">
		/// the id of the element that will be used to
		/// initiate the drag.
		/// </param>
		[ScriptName("setHandleElId")]
		public void SetHandleElId(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Allows you to set an element outside of the linked element as a drag
		/// handle
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">id of the element that will be used to initiate the drag</param>
		[ScriptName("setOuterHandleElId")]
		public void SetOuterHandleElId(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Remove all drag and drop hooks for this element</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("unreg")]
		public void Unreg()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns true if this instance is locked, or the drag drop mgr is locked
		/// (meaning that all drag/drop is disabled on the page.)
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <returns>
		/// true if this obj or all drag/drop is locked, else
		/// false
		/// </returns>
		[ScriptName("isLocked")]
		public bool IsLocked()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Allows you to specify a tag name that should not start a drag operation
		/// when clicked. This is designed to facilitate embedding links within a
		/// drag handle that do something other than start the drag.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="tagName">the type of element to exclude</param>
		[ScriptName("addInvalidHandleType")]
		public void AddInvalidHandleType(string tagName)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Lets you to specify an element id for a child of a drag handle
		/// that should not initiate a drag
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">the element id of the element you wish to ignore</param>
		[ScriptName("addInvalidHandleId")]
		public void AddInvalidHandleId(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Lets you specify a css class of elements that will not initiate a drag</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="cssClass">the class of the elements you wish to ignore</param>
		[ScriptName("addInvalidHandleClass")]
		public void AddInvalidHandleClass(string cssClass)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Unsets an excluded tag name set by addInvalidHandleType</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="tagName">the type of element to unexclude</param>
		[ScriptName("removeInvalidHandleType")]
		public void RemoveInvalidHandleType(string tagName)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Unsets an invalid handle id</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">the id of the element to re-enable</param>
		[ScriptName("removeInvalidHandleId")]
		public void RemoveInvalidHandleId(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Unsets an invalid css class</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="cssClass">
		/// the class of the element(s) you wish to
		/// re-enable
		/// </param>
		[ScriptName("removeInvalidHandleClass")]
		public void RemoveInvalidHandleClass(string cssClass)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks the tag exclusion list to see if this click should be ignored</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="node">the HTMLElement to evaluate</param>
		/// <returns>true if this is a valid tag type, false if not</returns>
		[ScriptName("isValidHandleChild")]
		public bool IsValidHandleChild(System.Html.Element node)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// By default, the element can be dragged any place on the screen. Use
		/// this method to limit the horizontal travel of the element. Pass in
		/// 0,0 for the parameters if you want to lock the drag to the y axis.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="iLeft">the number of pixels the element can move to the left</param>
		/// <param name="iRight">
		/// the number of pixels the element can move to the
		/// right
		/// </param>
		/// <param name="iTickSize">
		/// optional parameter for specifying that the
		/// element
		/// should move iTickSize pixels at a time.
		/// </param>
		[ScriptName("setXConstraint")]
		public void SetXConstraint(int iLeft, int iRight, int iTickSize)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Clears any constraints applied to this instance. Also clears ticks
		/// since they can&apos;t exist independent of a constraint at this time.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("clearConstraints")]
		public void ClearConstraints()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Clears any tick interval defined for this instance</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("clearTicks")]
		public void ClearTicks()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// By default, the element can be dragged any place on the screen. Set
		/// this to limit the vertical travel of the element. Pass in 0,0 for the
		/// parameters if you want to lock the drag to the x axis.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="iUp">the number of pixels the element can move up</param>
		/// <param name="iDown">the number of pixels the element can move down</param>
		/// <param name="iTickSize">
		/// optional parameter for specifying that the
		/// element should move iTickSize pixels at a time.
		/// </param>
		[ScriptName("setYConstraint")]
		public void SetYConstraint(int iUp, int iDown, int iTickSize)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>resetConstraints must be called if you manually reposition a dd element.</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="maintainOffset"></param>
		[ScriptName("resetConstraints")]
		public void ResetConstraints(bool maintainOffset)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>toString method</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <returns>string representation of the dd obj</returns>
		[ScriptName("toString")]
		public string ToString()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Abstract method called when this element fist begins hovering over
		/// another DragDrop obj
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mousemove event</param>
		/// <param name="id">
		/// In POINT mode, the element
		/// id this is hovering over. In INTERSECT mode, an array of one or more
		/// dragdrop items being hovered over.
		/// </param>
		[ScriptName("onDragEnter")]
		public void OnDragEnter(System.Html.ElementEvent e, string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Abstract method called when this element fist begins hovering over
		/// another DragDrop obj
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mousemove event</param>
		/// <param name="id">
		/// In POINT mode, the element
		/// id this is hovering over. In INTERSECT mode, an array of one or more
		/// dragdrop items being hovered over.
		/// </param>
		[ScriptName("onDragEnter")]
		public void OnDragEnter(System.Html.ElementEvent e, ext.dd.DragDrop[] id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Abstract method called when this element is hovering over another
		/// DragDrop obj
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mousemove event</param>
		/// <param name="id">
		/// In POINT mode, the element
		/// id this is hovering over. In INTERSECT mode, an array of dd items
		/// being hovered over.
		/// </param>
		[ScriptName("onDragOver")]
		public void OnDragOver(System.Html.ElementEvent e, string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Abstract method called when this element is hovering over another
		/// DragDrop obj
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mousemove event</param>
		/// <param name="id">
		/// In POINT mode, the element
		/// id this is hovering over. In INTERSECT mode, an array of dd items
		/// being hovered over.
		/// </param>
		[ScriptName("onDragOver")]
		public void OnDragOver(System.Html.ElementEvent e, ext.dd.DragDrop[] id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Abstract method called when we are no longer hovering over an element</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mousemove event</param>
		/// <param name="id">
		/// In POINT mode, the element
		/// id this was hovering over. In INTERSECT mode, an array of dd items
		/// that the mouse is no longer over.
		/// </param>
		[ScriptName("onDragOut")]
		public void OnDragOut(System.Html.ElementEvent e, string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Abstract method called when we are no longer hovering over an element</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mousemove event</param>
		/// <param name="id">
		/// In POINT mode, the element
		/// id this was hovering over. In INTERSECT mode, an array of dd items
		/// that the mouse is no longer over.
		/// </param>
		[ScriptName("onDragOut")]
		public void OnDragOut(System.Html.ElementEvent e, ext.dd.DragDrop[] id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Abstract method called when this item is dropped on another DragDrop
		/// obj
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mouseup event</param>
		/// <param name="id">
		/// In POINT mode, the element
		/// id this was dropped on. In INTERSECT mode, an array of dd items this
		/// was dropped on.
		/// </param>
		[ScriptName("onDragDrop")]
		public void OnDragDrop(System.Html.ElementEvent e, string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Abstract method called when this item is dropped on another DragDrop
		/// obj
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the mouseup event</param>
		/// <param name="id">
		/// In POINT mode, the element
		/// id this was dropped on. In INTERSECT mode, an array of dd items this
		/// was dropped on.
		/// </param>
		[ScriptName("onDragDrop")]
		public void OnDragDrop(System.Html.ElementEvent e, ext.dd.DragDrop[] id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// 
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// 
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// 
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// &lt;/code&gt;&lt;/pre&gt;
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="constrainTo">The element to constrain to.</param>
		/// <param name="pad">
		/// Pad provides a way to specify &quot;padding&quot; of the constraints,
		/// and can be either a number for symmetrical padding (4 would be equal to {left:4, right:4, top:4, bottom:4}) or
		/// an object containing the sides to pad. For example: {right:10, bottom:10}
		/// </param>
		/// <param name="inContent">Constrain the draggable in the content box of the element (inside padding and borders)</param>
		[ScriptName("constrainTo")]
		public void ConstrainTo(object constrainTo, object pad, bool inContent)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// 
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// 
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// 
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// &lt;/code&gt;&lt;/pre&gt;
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="constrainTo">The element to constrain to.</param>
		/// <param name="pad">
		/// Pad provides a way to specify &quot;padding&quot; of the constraints,
		/// and can be either a number for symmetrical padding (4 would be equal to {left:4, right:4, top:4, bottom:4}) or
		/// an object containing the sides to pad. For example: {right:10, bottom:10}
		/// </param>
		/// <param name="inContent">Constrain the draggable in the content box of the element (inside padding and borders)</param>
		[ScriptName("constrainTo")]
		public void ConstrainTo(object constrainTo, System.Number pad, bool inContent)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// 
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// 
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// 
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// &lt;/code&gt;&lt;/pre&gt;
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="constrainTo">The element to constrain to.</param>
		/// <param name="pad">
		/// Pad provides a way to specify &quot;padding&quot; of the constraints,
		/// and can be either a number for symmetrical padding (4 would be equal to {left:4, right:4, top:4, bottom:4}) or
		/// an object containing the sides to pad. For example: {right:10, bottom:10}
		/// </param>
		[ScriptName("constrainTo")]
		public void ConstrainTo(object constrainTo, object pad)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// 
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// 
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// 
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// &lt;/code&gt;&lt;/pre&gt;
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="constrainTo">The element to constrain to.</param>
		/// <param name="pad">
		/// Pad provides a way to specify &quot;padding&quot; of the constraints,
		/// and can be either a number for symmetrical padding (4 would be equal to {left:4, right:4, top:4, bottom:4}) or
		/// an object containing the sides to pad. For example: {right:10, bottom:10}
		/// </param>
		[ScriptName("constrainTo")]
		public void ConstrainTo(object constrainTo, System.Number pad)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// 
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// 
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// 
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Initializes the drag drop object&apos;s constraints to restrict movement to a certain element.
		///
		/// Usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var dd = new Ext.dd.DDProxy(&quot;dragDiv1&quot;, &quot;proxytest&quot;,
		/// { dragElId: &quot;existingProxyDiv&quot; });
		/// dd.startDrag = function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// };
		/// &lt;/code&gt;&lt;/pre&gt;
		/// Or you can initalize it using the {@link Ext.Element} object:
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.get(&quot;dragDiv1&quot;).initDDProxy(&quot;proxytest&quot;, {dragElId: &quot;existingProxyDiv&quot;}, {
		/// startDrag : function(){
		/// this.constrainTo(&quot;parent-id&quot;);
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="constrainTo">The element to constrain to.</param>
		[ScriptName("constrainTo")]
		public void ConstrainTo(object constrainTo)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
